namespace Trade.Library.Common
{
    using System;

    /// <summary>
    /// 安全高效的类型转换帮助
    /// </summary>
    public class ConvertHelper
    {
        private object _obj;

        /// <summary>
        /// 该类可以把构造函数中传入的一个对象转换成需要的类型
        /// </summary>
        /// <param name="obj">传入的对象</param>
        public ConvertHelper(object obj)
        {
            this._obj = obj;
        }

        /// <summary>
        /// 转换为String对象
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return Convert.ToString(this._obj);
        }

        /// <summary>
        /// 将传入的对象转换为String，如果对象为空则返回string.Empty;如果对象不为空，则返回该对象的ToString重载属性。
        /// </summary>
        /// <example>
        /// 代码示例
        /// <code>
        /// object ss = new object();//新建一个对象
        /// string str = new Trade.Common.ConvertHelper(obj).String; //str的值为ToString重载属性返回值.
        /// </code>
        /// </example>
        /// <value>
        /// 将传入的对象转换为String，如果对象为空则返回string.Empty;如果对象不为空，则返回该对象的ToString重载属性。
        /// </value>
        /// <remarks>如果传入的对象为空,则返回string.Empty</remarks>
        public string String
        {
            get
            {
                return this.ToString();
            }
        }

        /// <summary>
        /// 将该类型转换为Bool，若转换失败返回null。
        /// </summary>
        /// <example>
        /// 代码示例
        /// <code>
        /// bool? b1 = new Trade.Common.ConvertHelper("true").ToBool;//b1为true
        /// </code>
        /// </example>
        /// <value>
        /// 将传入的对象转换为可空的bool(bool?)，若转换失败返回null。
        /// </value>
        /// <remarks>
        /// 传入的只能是TrueString或者FalseString,不能是其他(0，1也不行)，否则转换失败，返回null。
        /// </remarks>
        public bool? ToBool
        {
            get
            {
                if ((this._obj == null) || (this._obj == Convert.DBNull))
                {
                    return null;
                }
                if ((this.String.ToLower() == "false") || (this.String == "0"))
                {
                    return false;
                }
                return true;
            }
        }

        /// <summary>
        /// 将该类型转换为Byte，若转换失败返回null。
        /// </summary>
        /// <example>
        /// 代码示例
        /// <code>
        /// byte? b2 = new Trade.Common.ConvertHelper("200").ToByte;//b2值为200
        /// </code>
        /// </example>
        /// <value>
        /// 将传入的对象转换为可空的byte(byte?)，若转换失败返回null。
        /// </value>
        /// <remarks> 
        /// byte 为一个8为无符号整数，最大只能转换255。如果不能转换成byte，则返回null
        /// </remarks>
        public byte? ToByte
        {
            get
            {
                byte r;
                if (byte.TryParse(this.String, out r))
                {
                    return new byte?(r);
                }
                return null;
            }
        }

        /// <summary>
        /// 将该类型转换为DateTime，若转换失败返回null。
        /// </summary>
        /// <example>
        /// 代码示例
        /// <code>
        /// DateTime? r1 = new Trade.Common.ConvertHelper("2009-02-13").ToDateTime; //r2 为 2009-2-13 0:00:00
        /// DateTime? r2 = new Trade.Common.ConvertHelper("2009-02-13 14:20:37").ToDateTime;//r3 为 2009-2-13 14:20:37
        /// </code>
        /// </example>
        /// <value>
        /// 将传入的对象转换为可空的DateTime(DateTime?)，若转换失败返回null。
        /// </value>
        /// <remarks>如果传入的类型不能转换成DateTime,返回null</remarks>
        public DateTime? ToDateTime
        {
            get
            {
                DateTime r;
                if (DateTime.TryParse(this.String, out r))
                {
                    return new DateTime?(r);
                }
                return null;
            }
        }

        /// <summary>
        /// 将该类型转换为Decimal，若转换失败返回null。
        /// </summary>
        /// <example>
        /// 代码示例
        /// <code>
        /// decimal? d1 = new Trade.Common.ConvertHelper("2.01").ToDecimal;//2.01
        /// //abc 不能转换成decimal,返回null    
        /// </code>
        /// </example>
        /// <value>
        /// 将传入的对象转换为可空的decimal(decimal?)，若转换失败返回null。
        /// </value>
        /// <remarks>如果传入的类型不能转换成decimal,返回值为null</remarks>
        public decimal? ToDecimal
        {
            get
            {
                decimal r;
                if (decimal.TryParse(this.String, out r))
                {
                    return new decimal?(r);
                }
                return null;
            }
        }

        /// <summary>
        /// 将该类型转换为Double，若转换失败返回null。
        /// </summary>
        /// <example>
        /// 代码示例
        /// <code>
        /// double? d1 = new Trade.Common.ConvertHelper("2.01").ToDouble; // d1 2.01   
        /// </code>
        /// </example>
        /// <value>
        /// 将传入的对象转换为可空的Double(Double?)，若转换失败返回null。
        /// </value>
        /// <remarks>如果传入的类型不能转换成double,返回值为null</remarks>
        public double? ToDouble
        {
            get
            {
                double r;
                if (double.TryParse(this.String, out r))
                {
                    return new double?(r);
                }
                return null;
            }
        }

        /// <summary>
        /// 将该类型转换为Float，若转换失败返回null。
        /// </summary>
        /// <example>
        /// 代码示例
        /// <code>
        /// float? fo1 = new Trade.Common.ConvertHelper("2.01").ToFloat;//2.01
        /// </code>
        /// </example>
        /// <value>
        /// 将传入的对象转换为可空的float(float?)，若转换失败返回null。
        /// </value>
        /// <remarks>如果传入的类型不能转换成float,返回值为null</remarks>
        public float? ToFloat
        {
            get
            {
                float r;
                if (float.TryParse(this.String, out r))
                {
                    return new float?(r);
                }
                return null;
            }
        }

        /// <summary>
        /// 将该类型转换为Int32，若转换失败返回null。
        /// </summary>
        /// <example>
        /// 代码示例
        /// <code> 
        /// int? r1 = new Trade.Common.ConvertHelper("100").ToInt32;//r1值为100
        /// </code>
        /// </example>
        /// <value>
        /// 将传入的对象转换为可空的Int32(int?)，若转换失败返回null。
        /// </value>
        /// <remarks>
        /// 如果传入的类型不能转换成整数,则返回null
        /// </remarks>
        public int? ToInt32
        {
            get
            {
                int r;
                if (int.TryParse(this.String, out r))
                {
                    return new int?(r);
                }
                return null;
            }
        }

        /// <summary>
        /// 将该类型转换为Int64，若转换失败返回null。
        /// </summary>
        /// <example>
        /// 代码示例
        /// <code> 
        /// long? r1 = new Trade.Common.ConvertHelper("100").ToInt64;//r1 为 long 100
        /// </code>
        /// </example>
        /// <value>
        /// 将传入的对象转换为可空的Int64(long?)，若转换失败返回null。
        /// </value>
        /// <remarks>如果传入的类型不能转换成长整数,返回null</remarks>
        public long? ToInt64
        {
            get
            {
                long r;
                if (long.TryParse(this.String, out r))
                {
                    return new long?(r);
                }
                return null;
            }
        }
    }
}

